package com.young.security;

import com.young.security.utils.Base64;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;


public class RSAEncrypt {
  private static final String DEFAULT_PUBLIC_KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDe0vQcgnUqEOsdNe5OIkYdTRVL"
      + "\r" + "JLCYNSca7+vIMF1PeFM84M3tL8I+pbrd0K1iRCQ9mk0aKsMaUkhrX7ZeCIziZcm0" + "\r"
      + "tS364/dQ4eQBAm98M4pEj9Ijuwmhl4LbHDXJe/nh1wd7+ycDB9L2tkKJAybB0fP8" + "\r" + "6cZTKvNXB46wo3lJzwIDAQAB"
      + "\r";
  
  private static final String DEFAULT_PRIVATE_KEY = "X8axF4fQHTbcPgwBcXFIjcBbmtbjuSfRluVXCtafOCoBoHSsGxgNlgHlKm4N/oSM"
      + "\r" + "nz+7S1IU0V5Ya5okm3NaB4KotOWZ86w+sD2BCD0MK9zHVmEnNQIMumN6zFzAN5KJ" + "\r"
      + "6mlQBh2n5lG/X+XmyPtBxlM5TRdPlH8CCmJU9TmEOZmVQTaYCUO/w9crjyH1YJ+O" + "\r"
      + "d+J+zq73eaSy/8WJBIspIOxpRZA7V2qFFe2YgTot0I6zg9zIBUXwQ9bO7bQqfCL1" + "\r"
      + "LHJh6A8Zua5EP63RRUE08bcWFbZO7OlBNeYitLN3NBKYGZjCxc0qBhIZPFBGlRyR" + "\r"
      + "3WUxCBJdoVwEqINT0ZDi8VyZDYgNOq0YQv2/i4tQKLfgzUh0YJ5dkibFI3dzvusi" + "\r"
      + "TyydcFJoPV+d3Vp/mFvnHd27GKr7aB9WRqSeULq+okDJpFVtx66YQJ/eUUu9JGrt" + "\r"
      + "VZ9N4dpp8j+/0FcZN/FSLnLizHr6fxSC+N33sHorgui8sXqb6E3vdaABYk6xStDN" + "\r"
      + "tOpFMC3v0G8tsRqHZdZabrkPBXczxY3j/qoexhHT7O+vCRL7g2QQHWkrJs9Hrb8H" + "\r"
      + "60G/9B44l8qf7a5nYiblEYFJPsIgWEI5SSydFAE1sFxfaynhDIa1KbxtYAvsik6I" + "\r"
      + "+iQkTAYR/mgosj6V8vH/Y2njkDYALT1FBE1nZCGXmdFPE9iJJ8HKuFMJMz35LOYf" + "\r"
      + "FX0tin/IoV1MTnoGQ8hRbUMAeccjb2G+2fLqLoM3/3/7K1xCBVrOSF5jekxgfnaI" + "\r"
      + "xx5rNoy6M0+Lj7DBqSwDfiTZL/2Af3osR8TxibmCDuffetYu2a63dg==" + "\r";
  
  /**
   * 私钥
   */
  private RSAPrivateKey privateKey;
  
  /**
   * 公钥
   */
  private RSAPublicKey publicKey;
  
  /**
   * 字节数据转字符串专用集合
   */
  private static final char[] HEX_CHAR = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e',
      'f'};
  
  /**
   * 获取私钥
   *
   * @return 当前的私钥对象
   */
  public RSAPrivateKey getPrivateKey() {
    return privateKey;
  }
  
  /**
   * 获取公钥
   *
   * @return 当前的公钥对象
   */
  public RSAPublicKey getPublicKey() {
    return publicKey;
  }
  
  /**
   * 随机生成密钥对
   */
  public void genKeyPair() {
    KeyPairGenerator keyPairGen = null;
    try {
      keyPairGen = KeyPairGenerator.getInstance("RSA");
    } catch (NoSuchAlgorithmException e) {
      e.printStackTrace();
    }
    keyPairGen.initialize(512, new SecureRandom());
    KeyPair keyPair = keyPairGen.generateKeyPair();
    this.privateKey = (RSAPrivateKey) keyPair.getPrivate();
    this.publicKey = (RSAPublicKey) keyPair.getPublic();
  }
  
  /**
   * 从文件中输入流中加载公钥
   *
   * @param in 公钥输入流
   * @throws Exception 加载公钥时产生的异常
   */
  public void loadPublicKey(InputStream in) throws Exception {
    try {
      BufferedReader br = new BufferedReader(new InputStreamReader(in));
      String readLine = null;
      StringBuilder sb = new StringBuilder();
      while ((readLine = br.readLine()) != null) {
        if (readLine.charAt(0) == '-') {
          continue;
        } else {
          sb.append(readLine);
          sb.append('\r');
        }
      }
      loadPublicKey(sb.toString());
    } catch (IOException e) {
      throw new Exception("公钥数据流读取错误");
    } catch (NullPointerException e) {
      throw new Exception("公钥输入流为空");
    }
  }
  
  /**
   * 从字符串中加载公钥
   *
   * @param publicKeyStr 公钥数据字符串
   * @throws Exception 加载公钥时产生的异常
   */
  public void loadPublicKey(String publicKeyStr) throws Exception {
    try {
      byte[] buffer = Base64.decode(publicKeyStr);
      KeyFactory keyFactory = KeyFactory.getInstance("RSA");
      X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
      this.publicKey = (RSAPublicKey) keyFactory.generatePublic(keySpec);
    } catch (NoSuchAlgorithmException e) {
      throw new Exception("无此算法");
    } catch (InvalidKeySpecException e) {
      throw new Exception("公钥非法");
    } catch (NullPointerException e) {
      throw new Exception("公钥数据为空");
    }
  }
  
  /**
   * 从文件中加载私钥
   *
   * @throws Exception
   */
  public void loadPrivateKey(InputStream in) throws Exception {
    try {
      BufferedReader br = new BufferedReader(new InputStreamReader(in));
      String readLine = null;
      StringBuilder sb = new StringBuilder();
      while ((readLine = br.readLine()) != null) {
        if (readLine.charAt(0) == '-') {
          continue;
        } else {
          sb.append(readLine);
          sb.append('\r');
        }
      }
      loadPrivateKey(sb.toString());
    } catch (IOException e) {
      throw new Exception("私钥数据读取错误");
    } catch (NullPointerException e) {
      throw new Exception("私钥输入流为空");
    }
  }
  
  public void loadPrivateKey(String privateKeyStr) throws Exception {
    try {
      byte[] buffer = Base64.decode(privateKeyStr);
      PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
      KeyFactory keyFactory = KeyFactory.getInstance("RSA");
      this.privateKey = (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
    } catch (NoSuchAlgorithmException e) {
      throw new Exception("无此算法");
    } catch (InvalidKeySpecException e) {
      e.printStackTrace();
      throw new Exception("私钥非法");
    } catch (NullPointerException e) {
      throw new Exception("私钥数据为空");
    }
  }
  
  /**
   * 加密过程
   *
   * @param publicKey     公钥
   * @param plainTextData 明文数据
   * @return
   * @throws Exception 加密过程中的异常信息
   */
  public byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData) throws Exception {
    if (publicKey == null) {
      throw new Exception("加密公钥为空, 请设置");
    }
    Cipher cipher = null;
    try {
      cipher = Cipher.getInstance("RSA");// , new BouncyCastleProvider());
      cipher.init(Cipher.ENCRYPT_MODE, publicKey);
      byte[] output = cipher.doFinal(plainTextData);
      return output;
    } catch (NoSuchAlgorithmException e) {
      throw new Exception("无此加密算法");
    } catch (NoSuchPaddingException e) {
      e.printStackTrace();
      return null;
    } catch (InvalidKeyException e) {
      throw new Exception("加密公钥非法,请检查");
    } catch (IllegalBlockSizeException e) {
      throw new Exception("明文长度非法");
    } catch (BadPaddingException e) {
      throw new Exception("明文数据已损坏");
    }
  }
  
  /**
   * 解密过程
   *
   * @param privateKey 私钥
   * @param cipherData 密文数据
   * @return 明文
   * @throws Exception 解密过程中的异常信息
   */
  public byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData) throws Exception {
    if (privateKey == null) {
      throw new Exception("解密私钥为空, 请设置");
    }
    Cipher cipher = null;
    try {
      cipher = Cipher.getInstance("RSA");// , new BouncyCastleProvider());
      cipher.init(Cipher.DECRYPT_MODE, privateKey);
      byte[] output = cipher.doFinal(cipherData);
      return output;
    } catch (NoSuchAlgorithmException e) {
      throw new Exception("无此解密算法");
    } catch (NoSuchPaddingException e) {
      e.printStackTrace();
      return null;
    } catch (InvalidKeyException e) {
      throw new Exception("解密私钥非法,请检查");
    } catch (IllegalBlockSizeException e) {
      throw new Exception("密文长度非法");
    } catch (BadPaddingException e) {
      throw new Exception("密文数据已损坏");
    }
  }
  
  /**
   * 字节数据转十六进制字符串
   *
   * @param data 输入数据
   * @return 十六进制内容
   */
  public static String byteArrayToString(byte[] data) {
    StringBuilder stringBuilder = new StringBuilder();
    for (int i = 0; i < data.length; i++) {
      // 取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移
      stringBuilder.append(HEX_CHAR[(data[i] & 0xf0) >>> 4]);
      // 取出字节的低四位 作为索引得到相应的十六进制标识符
      stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);
      if (i < data.length - 1) {
        stringBuilder.append(' ');
      }
    }
    return stringBuilder.toString();
  }
  
  public static void main(String[] args) {
    RSAEncrypt rsaEncrypt = new RSAEncrypt();
    rsaEncrypt.genKeyPair();
    
    String p = RSAEncrypt.byteArrayToString(rsaEncrypt.getPrivateKey().getEncoded());
    
    System.out.println(p);
    // 加载公钥
    try {
      rsaEncrypt.loadPublicKey(RSAEncrypt.DEFAULT_PUBLIC_KEY);
      System.out.println("加载公钥成功");
    } catch (Exception e) {
      System.err.println(e.getMessage());
      System.err.println("加载公钥失败");
    }
    
    // 加载私钥
    try {
      rsaEncrypt.loadPrivateKey(RSAEncrypt.DEFAULT_PRIVATE_KEY);
      System.out.println("加载私钥成功");
    } catch (Exception e) {
      System.err.println(e.getMessage());
      System.err.println("加载私钥失败");
    }
    
    // 测试字符串
    String encryptStr = "abc";
    System.out.println("私钥长度：" + rsaEncrypt.getPrivateKey().toString().length());
    System.out.println("公钥长度：" + rsaEncrypt.getPublicKey().toString().length());
    try {
      // 加密
      byte[] cipher = rsaEncrypt.encrypt(rsaEncrypt.getPublicKey(), encryptStr.getBytes());
      
      // 解密
      byte[] plainText = rsaEncrypt.decrypt(rsaEncrypt.getPrivateKey(), cipher);
      
      System.out.println("密文长度:" + cipher.length);
      System.out.println(RSAEncrypt.byteArrayToString(cipher));
      System.out.println("明文长度:" + plainText.length);
      System.out.println(RSAEncrypt.byteArrayToString(plainText));
      System.out.println(new String(plainText));
    } catch (Exception e) {
      System.err.println(e.getMessage());
    }
  }
}
